namespace System
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>These functions are available on every Function object (any JavaScript function).</summary>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\ext-core\src\core\Ext.js</definedin>
	/// <definedin>src\ext-core\src\core\Ext.js</definedin>
	[ScriptName("Function")]
	[IgnoreNamespace()]
	[Imported()]
	public sealed partial class FunctionExtensions
	{
		
		#region Snippets
		public static implicit operator System.Function (FunctionExtensions thisObject)
		{
				throw new System.Exception ("Imported - Not Implemented");
		}
		
		public static implicit operator FunctionExtensions (System.Function otherObject)
		{
				throw new System.Exception ("Imported - Not Implemented");
		}
		#endregion
		
		#region Constructors
		private FunctionExtensions()
		{
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
		/// Call directly on any function. Example: myFunction.createCallback(arg1, arg2)
		/// Will create a function that is bound to those 2 args. If a specific scope is required in the
		/// callback, use {@link #createDelegate} instead. The function returned by createCallback always
		/// executes in the window scope.
		/// This method is required when you want to pass arguments to a callback function. If no arguments
		/// are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).
		/// However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function
		/// would simply execute immediately when the code is parsed. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // clicking the button alerts &quot;Hi, Fred&quot;
		/// new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody(),
		/// handler: sayHi.createCallback(&apos;Fred&apos;)
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
		/// Call directly on any function. Example: &lt;code&gt;myFunction.createCallback(arg1, arg2)&lt;/code&gt;
		/// Will create a function that is bound to those 2 args. &lt;b&gt;If a specific scope is required in the
		/// callback, use {@link #createDelegate} instead.&lt;/b&gt; The function returned by createCallback always
		/// executes in the window scope.
		/// &lt;p&gt;This method is required when you want to pass arguments to a callback function. If no arguments
		/// are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).
		/// However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function
		/// would simply execute immediately when the code is parsed. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // clicking the button alerts &quot;Hi, Fred&quot;
		/// new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody(),
		/// handler: sayHi.createCallback(&apos;Fred&apos;)
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The new function</returns>
		[ScriptName("createCallback")]
		public System.Function CreateCallback()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = sayHi.createSequence(function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// </summary>
		/// <htmlSummary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = sayHi.createSequence(function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="fcn">The function to sequence</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the passed function is executed.
		/// &lt;b&gt;If omitted, defaults to the scope in which the original function is called or the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createSequence")]
		public System.Function CreateSequence(System.Delegate fcn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = sayHi.createSequence(function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// </summary>
		/// <htmlSummary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = sayHi.createSequence(function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="fcn">The function to sequence</param>
		/// <returns>The new function</returns>
		[ScriptName("createSequence")]
		public System.Function CreateSequence(System.Delegate fcn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = sayHi.createInterceptor(function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// </summary>
		/// <htmlSummary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = sayHi.createInterceptor(function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="fcn">The function to call before the original</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the passed function is executed.
		/// &lt;b&gt;If omitted, defaults to the scope in which the original function is called or the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createInterceptor")]
		public System.Function CreateInterceptor(System.Delegate fcn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = sayHi.createInterceptor(function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// </summary>
		/// <htmlSummary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = sayHi.createInterceptor(function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="fcn">The function to call before the original</param>
		/// <returns>The new function</returns>
		[ScriptName("createInterceptor")]
		public System.Function CreateInterceptor(System.Delegate fcn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: this.myFunction.createDelegate(this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;this.myFunction.createDelegate(this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: this.myFunction.createDelegate(this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;this.myFunction.createDelegate(this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: this.myFunction.createDelegate(this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;this.myFunction.createDelegate(this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: this.myFunction.createDelegate(this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;this.myFunction.createDelegate(this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: this.myFunction.createDelegate(this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;this.myFunction.createDelegate(this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, sayHi.createDelegate(btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Number millis, object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Number millis, object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Number millis, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Number millis, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// sayHi.defer(2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// (function(){
		/// alert(&apos;Anonymous&apos;);
		/// }).defer(100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Number millis)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
